// 创建一个axios实例，设置默认的baseURL，等参数
import axios from 'axios'
// 从环境变量中获取VITE_CHEXING
const chexing = import.meta.env.VITE_CHEXING
const baseURL = import.meta.env.VITE_BASE_URL
export const request = axios.create({
  baseURL: baseURL,
  timeout: 60000
})

// 获取vin字典
let vin_dict = await get_vin_dict()
console.log(vin_dict)
// {last_1: 'LNBMCUAK0TT189500', last_2: 'LNBMCUAKXTT189469',.....last_100: 'LNBMCUAK0TT189468'}
export let g_last_vin_list = {}
for (const key in vin_dict) {
  g_last_vin_list[vin_dict[key].slice(-6)] = key
}
// console.log(g_last_vin_list)
// {180311:'last_100', 180312:'last_99', ..., 180410:'last_1'}

///////////////////
// 缓存配置常量
const CACHE_EXPIRY_TIME = 7 * 24 * 60 * 60 * 1000 // 缓存7天
const CACHE_PREFIX = 'coord_threejs_cache_'
export let CACHE_KEY_VIN_LIST = []
// 从localStorage获取缓存数据的函数
function getCachedDataByLast(last: string) {
  // 将last_i的key，装换为vin后6为数
  const vin = vin_dict[last].slice(-6)
  return getCachedDataByVin(vin)
}

export function getCachedDataByVin(vin: string) {
  return getCachedData(CACHE_PREFIX + vin)
}

function getCachedData(cache_key: string) {
  try {
    const cachedString = localStorage.getItem(cache_key)
    if (!cachedString) return null

    const cachedData = JSON.parse(cachedString)
    const now = Date.now()

    // 检查缓存是否过期
    if (cachedData.expiryTime && now > cachedData.expiryTime) {
      // 缓存已过期，删除它
      localStorage.removeItem(cache_key)
      return null
    }

    return cachedData.value
  } catch (error) {
    console.error('Error retrieving cached data:', error)
    return null
  }
}

// 将数据存入localStorage的函数
function setCachedData(key: string, value: any) {
  try {
    // 将last_i的key，装换为vin后6为数
    const vin = vin_dict[key].slice(-6)
    const cacheData = {
      value: value,
      expiryTime: Date.now() + CACHE_EXPIRY_TIME
    }
    localStorage.setItem(CACHE_PREFIX + vin, JSON.stringify(cacheData))

    updateCacheKeyVinList()
  } catch (error) {
    console.error('Error saving data to cache:', error)
    // 存储满时的处理
    if (error.name === 'QuotaExceededError') {
      // 简单的缓存清理策略 - 清除最早的缓存
      clearOldestCache()
      // 尝试重新存储
      try {
        const cacheData = {
          value: value,
          expiryTime: Date.now() + CACHE_EXPIRY_TIME
        }
        localStorage.setItem(CACHE_PREFIX + vin, JSON.stringify(cacheData))
      } catch (e) {
        console.warn('Failed to cache data even after cleanup')
      }
    }
  }
}

// 清除最早的缓存项（用于存储空间满时）
function clearOldestCache() {
  try {
    let oldestKey = null
    let oldestTime = Infinity

    // 遍历所有缓存项找出最早的
    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i)
      if (key && key.startsWith(CACHE_PREFIX)) {
        try {
          const cachedString = localStorage.getItem(key)
          const cachedData = JSON.parse(cachedString)
          if (cachedData.expiryTime && cachedData.expiryTime < oldestTime) {
            oldestTime = cachedData.expiryTime
            oldestKey = key
          }
        } catch (e) {
          // 忽略无效的缓存项
        }
      }
    }

    // 删除最早的缓存项
    if (oldestKey) {
      localStorage.removeItem(oldestKey)
    }
  } catch (error) {
    console.error('Error clearing oldest cache:', error)
  }
  updateCacheKeyVinList()
}

// 获取当前storage中的所有缓存键
function getAllCacheKeys() {
  const cacheKeys = []
  for (let i = 0; i < localStorage.length; i++) {
    const key = localStorage.key(i)
    if (key && key.startsWith(CACHE_PREFIX)) {
      cacheKeys.push(key)
    }
  }
  return cacheKeys
}

// 将缓存键转换为vin后6位数
function convertCacheKeyToVin(key: string) {
  return key.replace(CACHE_PREFIX, '')
}

// 通过vin后6位数，获取缓存键
function getCacheKeyByVin(vin: string) {
  return CACHE_PREFIX + vin
}

function updateCacheKeyVinList() {
  CACHE_KEY_VIN_LIST = getAllCacheKeys().map(convertCacheKeyToVin)
}
// 更新缓存键vin列表
updateCacheKeyVinList()

// 优化后的request_coorddata函数（带缓存）
export async function request_coorddata(last_i: string = 'last_1') {
  // 创建基于参数的缓存键
  const cacheKey = last_i

  // 尝试从缓存获取数据
  const cachedData = getCachedDataByLast(last_i)
  if (cachedData) {
    console.log('Using cached coordinate data for:', last_i)
    return cachedData
  }

  // 缓存未命中，发起网络请求
  console.log('Fetching fresh coordinate data for:', last_i)
  // 将车型转换为小写
  const response = await request.get(`/coord/${chexing.toLowerCase()}/`)
  console.log('response', response)
  let coorddata: any[] = []
  if (response.data.results) {
    coorddata = response.data.results
  } else {
    coorddata = response.data
  }
  // coorddata 是一个数组，每个元素是一个特征点的坐标，包含特征点号和坐标方向，名义值，last100台的误差值
  console.log('coorddata', coorddata)

  // 解析数据
  const coorddataobj = parse_coorddata(coorddata, last_i)

  // 将解析后的数据存入缓存
  setCachedData(cacheKey, coorddataobj)

  return coorddataobj
}

function parse_coorddata(coorddata: any, last_i: string) {
  // console.log(coorddata)
  const coorddataobj = {}
  // 存放遍历过程中发现的异常点，后续进行删除
  const remove_keys = new Set()
  // 解析出所有特征点号
  for (const item of coorddata) {
    // console.log(item)
    // 如果特征点号不在coorddataobj中，就添加它
    let key = item.特征点号
    if (!(key in coorddataobj)) {
      coorddataobj[key] = {}
      coorddataobj[key].特征点号 = item.特征点号
    }

    // 如果没有方向属性，就添加它
    // console.log(coorddataobj[item.特征点号], '0000')
    if (!coorddataobj[key].hasOwnProperty('名义值')) {
      coorddataobj[key].名义值 = {}
      //   console.log(coorddataobj[key].名义值, '1111')
    }
    if (item.方向 == 'X') {
      coorddataobj[key].名义值.x = item.名义值
    }
    if (item.方向 == 'Y') {
      coorddataobj[key].名义值.y = item.名义值
    }
    if (item.方向 == 'Z') {
      coorddataobj[key].名义值.z = item.名义值
    }
    // console.log(coorddataobj[key])
    // console.log(coorddataobj[key].名义值, '2222')

    // 将last1-100的误差值添加到coorddataobj中

    // console.log('1111 item.方向', item.方向)

    let value = item[last_i]
    // console.log('11111111  item[last_i]:', key, last_i, value)
    // 如果last_i属性的值为空字符串，就将其添加到remove_keys中
    if (!(value < 5 && value > -5)) {
      remove_keys.add(key)
      continue
    }

    let last = 'last'

    // 如果last属性不在coorddataobj[key]中，就添加它
    if (!coorddataobj[key].hasOwnProperty(last)) {
      coorddataobj[key][last] = {}
    }

    if (item.方向 == 'X') {
      coorddataobj[key][last].x = value
    }
    if (item.方向 == 'Y') {
      coorddataobj[key][last].y = value
    }
    if (item.方向 == 'Z') {
      // console.log(item[last_i], '3333')
      coorddataobj[key][last].z = value
      // console.log(coorddataobj[key][last_i], '4444')
    }
    // console.log('2222222222222222', coorddataobj[key][last])
  }
  //   打印coorddataobj的所有keys
  //   console.log(Object.keys(coorddataobj), 'coorddataobj的所有keys')
  //   console.log(coorddataobj['KN0001L'], '3333')
  console.log(remove_keys, 'remove_keys')
  // 遍历remove_keys，将异常点从coorddataobj中删除
  for (const key of remove_keys) {
    delete coorddataobj[key]
  }

  return coorddataobj
}

export async function get_vin_dict() {
  const response = await request.get(`/coord/vindict${chexing}/`)
  const vindict = response.data
  // console.log('vindict', vindict)
  return vindict
}
